from rest_framework.pagination import PageNumberPagination
from django.core.paginator import Paginator
from util.model_to_iterable import model_to_list

'1.1、drf通用的分页器，可以定义页面大小'
class APISizePageNumberPaginations():
    '''
    使用：
    1、pagenation = APIViewPageNumberPaginations(序列化器类,查询数据集,request,page_size=x)
    2、拿到页面数据，pagge_data = pagenatione.start()
    '''
    from rest_framework.pagination import PageNumberPagination
    class APIViewBasePaginations(PageNumberPagination):
        page_size = None  # 每页数据量
        page_query_param = 'page'  # ?page=1跳转页
        max_page_size = None  # 每页最大数据量
        page_size_query_param = 'size'

    def __init__(self, request, serializer, queryset,page_size=5,max_page_size=10):
        '''
        :param request: 当前的请求
        :param serializer:  模型类的序列化器类
        :param queryset:  要操作的模型对象
        :param page_size  每页数据量
        :param max_page_size 每页最大数据量
        '''
        self.request = request
        self.serializer = serializer
        self.queryset = queryset
        self.page_size = page_size
        self.max_page_size = max_page_size

    def start(self):
        # 1、实例分页对象
        paginat = self.APIViewBasePaginations()
        paginat.page_size = self.page_size #设置每页显示数据量
        paginat.max_page_size = self.max_page_size #设置每页最大显示数据量
        # 2、拿到分页后的数据
        page_list = paginat.paginate_queryset(queryset=self.queryset, request=self.request, view=self)
        # 3、对分页后的数据将进行序列化
        ser = self.serializer(instance=page_list, many=True)
        count = paginat.page.paginator.count  # 总数据量
        next_page = 1 if paginat.get_next_link() else 0  # 有下一页，返回1，没有返回0
        previous_page = 1 if paginat.get_previous_link() else 0  # 有上一页时，返回1，没有返回0
        page_size = paginat.page_size  # 每页大小
        pages = count // page_size  # 总页数
        current_page = self.request.query_params.get('page')

        try:
            current_page = int(current_page)
        except Exception as e:
            current_page = 'error'
        if count % page_size:
            pages += 1
        return {
            'code':200,
            'data': ser.data,  # 当前页的数据
            'next': next_page,  # 是否有下一页
            'previous': previous_page,  # 是否有上一页
            'count': count,  # 总数据量
            'pages': pages,  # 总页数
            'current_page': current_page,  # 当前的页数
            'page_size':self.page_size , #每页数据量
        }

'1.2、drf通用分页器，可以对传递进来的页码进行校验，对传递的页码大小进行异常处理，实例化时，只需要传递request,模型对象集合,模型对象序列化器类'
class GenericPageNumberPagination(PageNumberPagination):
    page_size = 5  # 默认每页数据量
    page_size_query_param = 'page_size'  # 每页大小，从地址栏获取的字符串
    page_query_param = 'page'  # ?page=1跳转页，获取页码的字符串
    max_page_size = 20  # 每页最大数据量

    def __init__(self, request, serializer, queryset):
        '''
        :param request: 当前的请求
        :param serializer:  模型类的序列化器类
        :param queryset:  要操作的模型对象
        '''
        self.request = request
        self.serializer = serializer
        self.queryset = queryset
    #获取前端传递的page_size的数值，给paginate_queryset方法使用的
    def get_page_size(self, request):
        #拿到当前类
        cls = GenericPageNumberPagination
        #拿到前端地址栏中的每页大小
        try:
            page_size = request.GET.get(cls.page_size_query_param)
            if not page_size:
                page_size = request.query_params.get(cls.page_size_query_param)
        except Exception as _:
            page_size = request.query_params.get(cls.page_size_query_param)

        if not page_size:
            page_size = request.query_params.get('size',cls.page_size)

        try:
            page_size = int(page_size)
        except Exception as _:
            page_size = cls.page_size
        self.page_size = page_size  # 给对象的page_size赋值
        return page_size
    #检测前端要获取的页码是否有问题
    def check_page(self):
        cls = GenericPageNumberPagination
        try:
            page =self.request.GET.get(cls.page_query_param)
            if not page:
                page = self.request.query_params.get(cls.page_query_param)
        except Exception as _:
            page = self.request.query_params.get(cls.page_query_param)
        #1、检验传递从page是否有问题，None，非数值字符串
        if not page:
            return f'没有携带参数{cls.page_query_param},无法查询'
        else:
            try:
                page = int(page)
            except Exception as _:
                return f'参数{cls.page_query_param}携带的不是数值，无法查询'
            if page<1:
                return f'参数{cls.page_query_param}携带的数值必须大于0'
        #2、判断传递的页码是否超过了最大的页数了
        page_size = self.get_page_size(self.request)
        page_tuple = divmod(len(self.queryset),page_size)
        all_page = page_tuple[0]
        if page_tuple[1]:
            all_page = page_tuple[0]+1
        if page > all_page:
            return f'查询的页码数为{page},超出最大的页数{all_page}范围'
        return page
    #处理数据
    def start(self):
        #1、没有如何数据时，直接返回
        if not self.queryset:
            return {'code':400,'error':'没有相关数据'}
        cls = GenericPageNumberPagination
        #2、检测page传递的数值是否有误
        page_result = self.check_page()
        if type(page_result)==str:
            return {'code':400,'error':page_result}
        # 3、拿到分页后的数据
        page_list = self.paginate_queryset(queryset=self.queryset, request=self.request, view=self)
        # 4、对分页后的数据将进行序列化
        ser = self.serializer(instance=page_list, many=True)
        #4.1、如果需要对数据进行下一步操作的话，可以循环操作data
        data = ser.data
        #5、拿到前端需要知道信息，下一页、上一页、总页数、每页大小、总数据量
        count = len(self.queryset)  # 总数据量
        next_page = 1 if self.get_next_link() else 0  # 有下一页，返回1，没有返回0
        previous_page = 1 if self.get_previous_link() else 0  # 有上一页时，返回1，没有返回0
        page_size = self.page_size  # 每页大小
        pages = count // page_size  # 总页数
        current_page = self.request.query_params.get(cls.page_query_param)  # 拿到当前页数

        #对于总页数，如果有余数，就需要加1
        if count % page_size:
            pages += 1
        return {
            'code': 200,
            'data': data,  # 当前页的数据
            'next': next_page,  # 是否有下一页
            'previous': previous_page,  # 是否有上一页
            'count': count,  # 总数据量
            'pages': pages,  # 总页数
            'current_page': int(current_page),  # 当前的页数
            'page_size': page_size,  # 每页数据量
        }


'1.3、drf和django都可以使用的分页器，传递的数据：模型对象集合/列表套字典数据'
class AllGenericPagination:
    '''
    web查询每日看护记录使用的分页器：
    1、使用的django的分页器
    2、传递的数据可以是数据集，也可以是列表套字典[{'id':,'name':},{}]
    '''
    page_query_params = 'page' #地址栏传递page，页码
    page_size_query_params = 'page_size'#地址栏传递page_size,页面大小
    page_size = 5 #默认的页面大小

    def __init__(self, object_list,request):
        self.object_list = object_list #数据集
        self.request = request #当前请求对象
        self.current_page = None
        self.page_size = None

    def get_page(self):
        cls = AllGenericPagination
        try:
            #django视图拿地址栏数据
            page = self.request.GET(cls.page_query_params)
            if not page:
                page = self.request.query_params.get(cls.page_query_params)
        except Exception as _:
            #drf视图拿地址栏数据
            page = self.request.query_params.get(cls.page_query_params)
        #1、检查page的参数是否有问题
        if not page:
            #没有携带page参数
            return f'没有携带{cls.page_query_params}参数'
        else:
            try:
                page = int(page)
            except Exception as _:
                #携带的参数不是数值
                return f'携带参数{cls.page_query_params}不是数值字符串'
        #2、检查page是否大于最大的页数
        page_tuple =divmod(len(self.object_list),self.get_page_size())
        all_page = page_tuple[0]
        if page_tuple[1]:
            all_page+=1
        if page > all_page:
            #查询的页码，超过最大页数了
            return f'查询的页码数是{page}超过最大页码数{all_page}'
        #3、将当前页面数赋值给
        self.current_page = page
        return page

    def get_page_size(self)->int:
        #page_size字符串
        cls = AllGenericPagination
        try:
            #django视图获取地址栏数据
            page_size = self.request.GET(cls.page_size_query_params)
            if not page_size:
                page_size = self.request.query_params.get(cls.page_size_query_params)
        except Exception as _:
            #drf视图获取地址栏数据
            page_size = self.request.query_params.get(cls.page_size_query_params)
        if not page_size:
            self.page_size = cls.page_size
        else:
            try:
                self.page_size = int(page_size)
            except Exception as _:
                self.page_size = cls.page_size
        return self.page_size

    def start(self):
        #1、检查page参数是否正常
        current_page = self.get_page()
        if type(current_page)==str:
            return {'code':400,'error':current_page}
        #2、获取到页面大小
        page_size = self.get_page_size()
        paginator = Paginator(object_list=self.object_list,per_page=page_size, orphans=0,allow_empty_first_page=True)

        #3、拿到当前页结果集
        page_data = paginator.get_page(current_page)
        #拿到最终的数据集
        res = page_data.object_list
        try:
            #all 或 filter结尾的查询数据集转成列表
            res = model_to_list(res)
        except Exception as e:
            #values结尾的查询数据集转成列表
            res = list(res)
        #4、响应数据处理

        #5、处理前端需要使用到的字段数据，上一页、下一页、总页数、每页大小、总数据量、当前页
        #当前页是否有下一页，上一页
        has_next = 0
        has_prev = 0
       #有下一页：当前页面大于等于1，当前页*页面大小 < 总数量
        if current_page>=1 and current_page*paginator.per_page < paginator.count:
            has_next =1
        #有上一页：当前页大于1，且总数据量要大于页面大小
        if current_page>1 and paginator.count>paginator.per_page: #有上一页，页数大于1，page_size小于总数据量
            has_prev =1

        dic ={
            'code':200,
            'msg':'获取数据成功',
            'data':res, #当前页的数据
            'current_page':current_page, #当前页数
            'count':paginator.count, #总数据量
            'page_size':paginator.per_page, #每页数据量
            'pages':paginator.num_pages, #总页数
            'next':has_next, #是否有下一页
            'previous':has_prev #是否有上一页
        }
        return dic

'''
1.1、使用方法：
page = APISizePageNumberPaginations(request,序列器类,查询数据集，page_size=页面大小)
data = psage.start()  #拿到的数据

1.2、使用方法： 内部对page和page_size进行异常处理的操作了
page = GenericPageNumberPagination(request,序列器类,查询数据集)
data = psage.start()  #拿到的数据

1.3、使用方法:
paginator = AllGenericPagination(列表套字典/queryset,request)
data = paginator.start()
'''

'''
使用方法： 内部对page和page_size进行异常处理的操作了
paginator = GenericPageNumberPagination(request,序列器类,查询数据集)
data = paginator.start()  #拿到的数据
'''